import * as fs from 'fs';
import * as path from 'path';
import { Logger } from '../../../../src/logger/Logger';

/**
 * Fuzz Prompt 增强器
 * 
 * 功能：将深度学习的知识注入到 LLM Prompt 中
 * - 真实的 Fuzz 测试示例（fuzzer.cpp 内函数写法）
 * - Fuzzer 框架使用示例（LLVMFuzzerTestOneInput）
 * - 常用头文件、依赖、GN 配置
 * - 完整的 BUILD.gn 示例（ohos_fuzztest、group）
 */
export class FuzzPromptEnhancer {
    private static comprehensiveKnowledge: any = null;
    private static gnPatterns: any = null;
    
    /**
     * 初始化知识库
     */
    public static initialize(extensionPath: string): void {
        const comprehensivePath = path.join(extensionPath, 'core', 'knowledge', 'comprehensive-all-projects.json');
        const gnPatternsPath = path.join(extensionPath, 'core', 'knowledge', 'gn-patterns.json');
        
        // 加载综合知识库
        if (fs.existsSync(comprehensivePath)) {
            try {
                const content = fs.readFileSync(comprehensivePath, 'utf-8');
                this.comprehensiveKnowledge = JSON.parse(content);
                Logger.info(`[FuzzPromptEnhancer] ✅ 加载综合知识库`);
            } catch (err: any) {
                Logger.error(`[FuzzPromptEnhancer] ❌ 加载综合知识库失败: ${err.message}`);
            }
        }
        
        // 加载 GN 模式
        if (fs.existsSync(gnPatternsPath)) {
            try {
                const content = fs.readFileSync(gnPatternsPath, 'utf-8');
                this.gnPatterns = JSON.parse(content);
                Logger.info(`[FuzzPromptEnhancer] ✅ 加载 GN 模式`);
            } catch (err: any) {
                Logger.error(`[FuzzPromptEnhancer] ❌ 加载 GN 模式失败: ${err.message}`);
            }
        }
    }
    
    /**
     * 获取 Fuzz 测试的真实示例（fuzzer.cpp 内函数写法）
     */
    public static getFuzzCodeExamples(): string {
        if (!this.comprehensiveKnowledge?.fuzzPatterns?.llvmFuzzerExamples) {
            return '';
        }
        
        const examples = this.comprehensiveKnowledge.fuzzPatterns.llvmFuzzerExamples.slice(0, 3);
        
        if (examples.length === 0) {
            return '';
        }
        
        return `
**📚 真实项目中的 Fuzz 测试示例（学习如何编写 fuzzer.cpp）：**

${examples.map((ex: string, idx: number) => `
**示例 ${idx + 1}：**
\`\`\`cpp
${ex}
\`\`\`
`).join('\n')}

**关键要点：**
- ✅ 所有示例都来自 OpenHarmony 23 个真实项目
- ✅ 学习它们的输入验证、数据处理、函数调用方式
- ✅ 模仿它们的代码风格和错误处理
`;
    }
    
    /**
     * 获取 MessageParcel 使用示例
     */
    public static getMessageParcelExamples(): string {
        if (!this.comprehensiveKnowledge?.fuzzPatterns?.messageParcelUsage) {
            return '';
        }
        
        const examples = this.comprehensiveKnowledge.fuzzPatterns.messageParcelUsage.slice(0, 5);
        
        if (examples.length === 0) {
            return '';
        }
        
        return `
**📦 MessageParcel 使用示例（来自真实项目）：**

${examples.map((ex: string) => `- \`${ex}\``).join('\n')}

**使用要点：**
- MessageParcel 是 OpenHarmony IPC 通信的核心
- 用于序列化/反序列化 Fuzz 数据
`;
    }
    
    /**
     * 获取输入验证模式
     */
    public static getInputValidationPatterns(): string {
        if (!this.comprehensiveKnowledge?.fuzzPatterns?.inputValidation) {
            return '';
        }
        
        const patterns = this.comprehensiveKnowledge.fuzzPatterns.inputValidation.slice(0, 3);
        
        if (patterns.length === 0) {
            return '';
        }
        
        return `
**🛡️ 输入验证模式（必须使用）：**

${patterns.map((pattern: string, idx: number) => `
**模式 ${idx + 1}：**
\`\`\`cpp
${pattern}
\`\`\`
`).join('\n')}
`;
    }
    
    /**
     * 获取常用头文件（按使用频率排序）
     */
    public static getCommonHeaders(): string {
        if (!this.comprehensiveKnowledge?.commonHeaders) {
            return '';
        }
        
        const headers = this.comprehensiveKnowledge.commonHeaders
            .slice(0, 20)
            .filter((h: any) => !h.header.includes('gtest') && !h.header.includes('gmock'))
            .slice(0, 15);
        
        if (headers.length === 0) {
            return '';
        }
        
        return `
**📄 OpenHarmony 项目中最常用的头文件（按使用频率）：**

${headers.map((h: any, idx: number) => `${idx + 1}. \`#include <${h.header}>\` (使用 ${h.count} 次)`).join('\n')}

**提示：** 这些头文件在 OpenHarmony 项目中被广泛使用，优先考虑它们。
`;
    }
    
    /**
     * 获取完整的 ohos_fuzztest BUILD.gn 示例
     */
    public static getCompleteFuzztestBuildGnExample(): string {
        if (!this.gnPatterns?.fuzztestTargets || this.gnPatterns.fuzztestTargets.length === 0) {
            return '';
        }
        
        const example = this.gnPatterns.fuzztestTargets[0];
        
        return `
**🔧 真实的 ohos_fuzztest BUILD.gn 示例（来自 OpenHarmony 项目）：**

\`\`\`gn
${example.fullExample}
\`\`\`

**关键字段：**
- \`module_out_path\`: "${example.moduleOutPath || '必须填写'}"
- \`fuzz_config_file\`: "${example.fuzzConfigFile || '必须填写！'}"
- \`sources\`: ${example.sources} 个源文件
- \`deps\`: ${example.deps} 个依赖
- \`external_deps\`: ${example.externalDeps} 个外部依赖

**❌ 严禁省略：**
- ❌ 不要省略 fuzz_config_file（这是最重要的！）
- ❌ 不要省略 deps 和 external_deps（即使很多也要全部列出）
- ❌ 不要使用 "... 其余XX项省略" 这样的标记
`;
    }
    
    /**
     * 获取 module_out_path 的正确格式
     */
    public static getModuleOutPathPatterns(): string {
        if (!this.gnPatterns?.moduleOutPathPatterns || this.gnPatterns.moduleOutPathPatterns.length === 0) {
            return '';
        }
        
        const patterns = this.gnPatterns.moduleOutPathPatterns.slice(0, 10);
        
        return `
**📍 module_out_path 的正确格式（来自 ${patterns.length} 个真实项目）：**

${patterns.map((p: any, idx: number) => `${idx + 1}. \`"${p.pattern}"\` (使用 ${p.count} 次)`).join('\n')}

**格式规范：** "subsystem/module" 或 "subsystem/module/submodule"
`;
    }
    
    /**
     * 获取 fuzz_config_file 的正确格式
     */
    public static getFuzzConfigFilePatterns(): string {
        if (!this.gnPatterns?.fuzzConfigFilePatterns || this.gnPatterns.fuzzConfigFilePatterns.length === 0) {
            return '';
        }
        
        const patterns = this.gnPatterns.fuzzConfigFilePatterns.slice(0, 5);
        
        return `
**📂 fuzz_config_file 的正确格式（来自真实项目）：**

${patterns.map((p: string, idx: number) => `${idx + 1}. \`"${p}"\``).join('\n')}

**格式规范：** 指向 project.xml 所在的目录路径
`;
    }
    
    /**
     * 获取常用的 external_deps
     */
    public static getCommonExternalDeps(): string {
        if (!this.gnPatterns?.commonExternalDeps || this.gnPatterns.commonExternalDeps.length === 0) {
            return '';
        }
        
        const deps = this.gnPatterns.commonExternalDeps.slice(0, 20);
        
        return `
**📦 OpenHarmony 项目中最常用的 external_deps：**

${deps.map((d: any, idx: number) => `${idx + 1}. "${d.dep}" (使用 ${d.count} 次)`).join('\n')}
`;
    }
    
    /**
     * 构建完整的增强 Prompt
     */
    public static buildEnhancedPrompt(basePrompt: string): string {
        const enhancements = [
            this.getFuzzCodeExamples(),
            this.getInputValidationPatterns(),
            this.getMessageParcelExamples(),
            this.getCommonHeaders(),
            this.getCompleteFuzztestBuildGnExample(),
            this.getModuleOutPathPatterns(),
            this.getFuzzConfigFilePatterns(),
            this.getCommonExternalDeps()
        ].filter(e => e.length > 0);
        
        if (enhancements.length === 0) {
            Logger.warn(`[FuzzPromptEnhancer] ⚠️  没有加载到知识库，使用基础 Prompt`);
            return basePrompt;
        }
        
        Logger.info(`[FuzzPromptEnhancer] ✅ 使用 ${enhancements.length} 项增强内容`);
        
        return `${basePrompt}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

## 🎓 深度学习知识库（来自 23 个 OpenHarmony 真实项目）

以下内容是从 23 个 OpenHarmony 项目中分析了 **34,156 个文件** 后提取的：
- ✅ 8,808 个源文件 (.cpp)
- ✅ 13,461 个头文件 (.h/.hpp)
- ✅ 2,400 个 Fuzz 文件
- ✅ 4,740 个 BUILD.gn 文件

**请严格参考这些真实示例生成代码，确保编译通过率 >90%！**

${enhancements.join('\n\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n')}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

**🎯 最终要求：**
1. ✅ 代码风格必须与上述真实示例保持一致
2. ✅ 所有头文件、依赖必须真实存在（参考常用列表）
3. ✅ BUILD.gn 配置必须完整（不允许省略任何字段）
4. ✅ 确保生成的代码可以直接编译通过
`;
    }
}

